Concepts > QuickOPC Concepts > QuickOPC Development Models > Imperative Programming Model > Imperative Programming Model for OPC Data (Classic and UA) > Modifying Information (OPC Data) > Writing to OPC Classic Items |
If you want to write a data value into a specific OPC item, call the WriteItemValue method, passing it the data value you want to write, arguments for machine name, server class, ItemID, and an optional data type.
// This example shows how to write a value into a single item. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-CSharp . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. using System; using OpcLabs.EasyOpc.DataAccess; using OpcLabs.EasyOpc.OperationModel; namespace DocExamples.DataAccess._EasyDAClient { partial class WriteItemValue { public static void Main1() { // Instantiate the client object. var client = new EasyDAClient(); try { client.WriteItemValue("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345); } catch (OpcException opcException) { Console.WriteLine("*** Failure: {0}", opcException.GetBaseException().Message); return; } Console.WriteLine("Success"); } } }
# This example shows how to write a value into a single item. # # Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . # OPC client and subscriber examples in PowerShell on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PowerShell . # Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own # a commercial license in order to use Online Forums, and we reply to every post. #requires -Version 5.1 using namespace OpcLabs.EasyOpc.DataAccess using namespace OpcLabs.EasyOpc.OperationModel # The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows . Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicCore.dll" Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassic.dll" Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicComponents.dll" # Instantiate the client object. $client = New-Object EasyDAClient try { [IEasyDAClientExtension]::WriteItemValue($client, "", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345) } catch [OpcException] { Write-Host "*** Failure: $($PSItem.Exception.GetBaseException().Message)" return } Write-Host "Success"
' Shows how to write into an OPC item that is of array type, and read the array value back. ' ' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . ' OPC client and subscriber examples in VB.NET on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBNET . ' Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own ' a commercial license in order to use Online Forums, and we reply to every post. Imports OpcLabs.EasyOpc.DataAccess Imports OpcLabs.EasyOpc.OperationModel Namespace DataAccess._EasyDAClient Partial Friend Class WriteItemValue Public Shared Sub Main1() Dim client = New EasyDAClient() Try client.WriteItemValue("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345) Catch opcException As OpcException Console.WriteLine("*** Failure: {0}", opcException.GetBaseException().Message) Exit Sub End Try End Sub End Class End Namespace
// This example shows how to write a value into a single item. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in PHP on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PHP . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. $Client = new COM("OpcLabs.EasyOpc.DataAccess.EasyDAClient"); try { $value = $Client->WriteItemValue("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345); } catch (com_exception $e) { printf("*** Failure: %s\n", $e->getMessage()); Exit(); }
// This example shows how to write a value into a single item. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in Object Pascal (Delphi) on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-OP . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. class procedure WriteItemValue.Main; var Client: OpcLabs_EasyOpcClassic_TLB._EasyDAClient; begin // Instantiate the client object Client := CoEasyDAClient.Create; try Client.WriteItemValue('', 'OPCLabs.KitServer.2', 'Simulation.Register_I4', 12345); except on E: EOleException do begin WriteLn(Format('*** Failure: %s', [E.GetBaseException.Message])); Exit; end; end; end;
// This example shows how to write a value into a single item. mle_outputtext.Text = "" // Instantiate the client object OLEObject client client = CREATE OLEObject client.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.EasyDAClient") // Modify value of an item TRY client.WriteItemValue("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345) CATCH (OLERuntimeError oleRuntimeError) mle_outputtext.Text = mle_outputtext.Text + "*** Failure: " + oleRuntimeError.Description + "~r~n" RETURN END TRY mle_outputtext.Text = mle_outputtext.Text + "~r~n" mle_outputtext.Text = mle_outputtext.Text + "Finished." + "~r~n"
# This example shows how to write a value into a single item. # # The Python for Windows (pywin32) extensions package is needed. Install it using "pip install pypiwin32". # CAUTION: We now recommend using Python.NET package instead. Full set of examples with Python.NET is available! # # Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . import win32com.client from pywintypes import com_error # Instantiate the client object client = win32com.client.Dispatch('OpcLabs.EasyOpc.DataAccess.EasyDAClient') # Perform the operation try: client.WriteItemValue('', 'OPCLabs.KitServer.2', 'Simulation.Register_I4', 12345) except com_error as e: print('*** Failure: ' + e.args[2][1] + ': ' + e.args[2][2]) exit()
REM This example shows how to write a value into a single item. REM REM Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . REM OPC client and subscriber examples in Visual Basic on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VB . REM Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own REM a commercial license in order to use Online Forums, and we reply to every post. Private Sub WriteItemValue_Main_Command_Click() OutputText = "" ' Instantiate the client object Dim client As New EasyDAClient On Error Resume Next Call client.WriteItemValue("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345) If Err.Number <> 0 Then OutputText = OutputText & "*** Failure: " & Err.Source & ": " & Err.Description & vbCrLf Exit Sub End If On Error GoTo 0 End Sub
Rem This example shows how to write a value into a single item. Rem Rem Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . Rem OPC client and subscriber examples in VBScript on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBScript . Rem Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own Rem a commercial license in order to use Online Forums, and we reply to every post. Option Explicit Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.DataAccess.EasyDAClient") On Error Resume Next Client.WriteItemValue "", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345 If Err.Number <> 0 Then WScript.Echo "*** Failure: " & Err.Source & ": " & Err.Description WScript.Quit End If On Error Goto 0
# This example shows how to write a value into a single item. # # Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . # OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python . # Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own # a commercial license in order to use Online Forums, and we reply to every post. # The QuickOPC package is needed. Install it using "pip install opclabs_quickopc". import opclabs_quickopc # Import .NET namespaces. from OpcLabs.EasyOpc.DataAccess import * from OpcLabs.EasyOpc.OperationModel import * # Instantiate the client object. client = EasyDAClient() # Perform the operation try: IEasyDAClientExtension.WriteItemValue(client, '', 'OPCLabs.KitServer.2', 'Simulation.Register_I4', 12345) except OpcException as opcException: print('*** Failure: ' + opcException.GetBaseException().Message, sep='') exit() print('Finished.')
In QuickOPC.NET, you can also pass in the ServerDescriptor and DAItemDescriptor objects in place of corresponding individual arguments.
// This example shows how to write a value into a single OPC XML-DA item. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-CSharp . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. using System; using OpcLabs.EasyOpc.DataAccess; using OpcLabs.EasyOpc.OperationModel; namespace DocExamples.DataAccess.Xml { class WriteItemValue { public static void Main1Xml() { // Instantiate the client object. var client = new EasyDAClient(); try { client.WriteItemValue( "http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Analog Types/Int", 12345); } catch (OpcException opcException) { Console.WriteLine("*** Failure: {0}", opcException.GetBaseException().Message); } } } }
' This example shows how to write a value into a single OPC XML-DA item. ' ' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . ' OPC client and subscriber examples in VB.NET on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBNET . ' Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own ' a commercial license in order to use Online Forums, and we reply to every post. Imports OpcLabs.EasyOpc.DataAccess Imports OpcLabs.EasyOpc.OperationModel Namespace DataAccess.Xml Partial Friend Class WriteItemValue Public Shared Sub Main1Xml() Dim client = New EasyDAClient() Try client.WriteItemValue("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Analog Types/Int", 12345) Catch opcException As OpcException Console.WriteLine("*** Failure: {0}", opcException.GetBaseException().Message) Exit Sub End Try End Sub End Class End Namespace
// This example shows how to write a value into a single OPC XML-DA item. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in Object Pascal (Delphi) on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-OP . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. class procedure WriteItemValue.MainXml; var Arguments: OleVariant; Client: OpcLabs_EasyOpcClassic_TLB._EasyDAClient; ItemValueArguments1: _DAItemValueArguments; Results: OleVariant; OperationResult: _OperationResult; begin ItemValueArguments1 := CoDAItemValueArguments.Create; ItemValueArguments1.ServerDescriptor.UrlString := 'http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx'; ItemValueArguments1.ItemDescriptor.ItemID := 'Static/Analog Types/Int'; ItemValueArguments1.Value := 12345; Arguments := VarArrayCreate([0, 0], varVariant); Arguments[0] := ItemValueArguments1; // Instantiate the client object Client := CoEasyDAClient.Create; TVarData(Results).VType := varArray or varVariant; TVarData(Results).VArray := PVarArray( Client.WriteMultipleItemValues(Arguments)); OperationResult := IInterface(Results[0]) as _OperationResult; if Not OperationResult.Succeeded then WriteLn(' *** Failure: ', OperationResult.Exception.GetBaseException.Message); VarClear(Results); VarClear(Arguments); end;
// This example shows how to write a value into a single OPC XML-DA item. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in PHP on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PHP . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. $ItemValueArguments1 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments"); $ItemValueArguments1->ServerDescriptor->UrlString = "http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx"; $ItemValueArguments1->ItemDescriptor->ItemID = "Static/Analog Types/Int"; $ItemValueArguments1->Value = 12345; $arguments[0] = $ItemValueArguments1; // Instantiate the client object. $Client = new COM("OpcLabs.EasyOpc.DataAccess.EasyDAClient"); $results = $Client->WriteMultipleItemValues($arguments); $OperationResult = $results[0]; if ($OperationResult->Succeeded) printf("Result: success\n"); else printf("Result: %s\n", $OperationResult->ErrorMessageBrief);
Rem This example shows how to write a value into a single OPC XML-DA item. Rem REM Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . REM OPC client and subscriber examples in Visual Basic on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VB . REM Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own REM a commercial license in order to use Online Forums, and we reply to every post. Private Sub WriteItemValue_MainXml_Command_Click() OutputText = "" Dim itemValueArguments1 As New DAItemValueArguments itemValueArguments1.serverDescriptor.UrlString = "http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx" itemValueArguments1.ItemDescriptor.ItemId = "Static/Analog Types/Int" itemValueArguments1.SetValue 12345 Dim arguments(0) As Variant Set arguments(0) = itemValueArguments1 ' Instantiate the client object Dim client As New EasyDAClient ' Modify values of nodes Dim results() As Variant results = client.WriteMultipleItemValues(arguments) Dim operationResult As operationResult: Set operationResult = results(0) If Not operationResult.Succeeded Then OutputText = OutputText & "*** Failure: " & operationResult.ErrorMessageBrief & vbCrLf End If End Sub
Rem This example shows how to write a value into a single OPC XML-DA item. Rem Rem Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . Rem OPC client and subscriber examples in VBScript on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBScript . Rem Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own Rem a commercial license in order to use Online Forums, and we reply to every post. Option Explicit Dim ItemValueArguments1: Set ItemValueArguments1 = CreateObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") ItemValueArguments1.ServerDescriptor.UrlString = "http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx" ItemValueArguments1.ItemDescriptor.ItemID = "Static/Analog Types/Int" ItemValueArguments1.Value = 12345 Dim arguments(0) Set arguments(0) = ItemValueArguments1 Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.DataAccess.EasyDAClient") Dim results: results = Client.WriteMultipleItemValues(arguments) Dim OperationResult: Set OperationResult = results(0) If OperationResult.Succeeded Then WScript.Echo "Result: success" Else WScript.Echo "Result: " & OperationResult.Exception.GetBaseException.Message End If
# This example shows how to write a value into a single OPC XML-DA item. # # Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . # OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python . # Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own # a commercial license in order to use Online Forums, and we reply to every post. # The QuickOPC package is needed. Install it using "pip install opclabs_quickopc". import opclabs_quickopc # Import .NET namespaces. from System import * from OpcLabs.EasyOpc import * from OpcLabs.EasyOpc.DataAccess import * from OpcLabs.EasyOpc.OperationModel import * # Instantiate the client object. client = EasyDAClient() # Perform the operation try: IEasyDAClientExtension.WriteItemValue(client, ServerDescriptor('http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx'), DAItemDescriptor('Static/Analog Types/Int'), Int32(12345)) except OpcException as opcException: print('*** Failure: ' + opcException.GetBaseException().Message, sep='') exit() print('Finished.')
For writing data values into multiple OPC items in an efficient manner, call the WriteMultipleItemValues method.
In QuickOPC.NET, you pass in an array of DAItemValueArguments objects, each specifying the location of OPC item, and the value to be written.
For an efficient writing into several items, use the WriteMultipleItemValues method.
// Shows how to write into multiple OPC items using a single method call, and read multiple item values back. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-CSharp . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. using System; using System.Diagnostics; using OpcLabs.BaseLib.OperationModel; using OpcLabs.EasyOpc.DataAccess; using OpcLabs.EasyOpc.DataAccess.OperationModel; namespace DocExamples.DataAccess._EasyDAClient { partial class WriteMultipleItemValues { public static void Main1() { // Instantiate the client object. var client = new EasyDAClient(); Console.WriteLine("Writing multiple item values..."); OperationResult[] resultArray = client.WriteMultipleItemValues( new[] { new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345), new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_BOOL", true), new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56) }); for (int i = 0; i < resultArray.Length; i++) { Debug.Assert(resultArray[i] != null); if (resultArray[i].Succeeded) Console.WriteLine($"Results[{i}]: success"); else { Debug.Assert(!(resultArray[i].Exception is null)); Console.WriteLine($"Results[{i}] *** Failure: {resultArray[i].ErrorMessageBrief}"); } } Console.WriteLine(); Console.WriteLine("Reading multiple item values..."); ValueResult[] valueResultArray = client.ReadMultipleItemValues("OPCLabs.KitServer.2", new DAItemDescriptor[] { "Simulation.Register_I4", "Simulation.Register_BOOL", "Simulation.Register_R4" }); for (int i = 0; i < valueResultArray.Length; i++) { Debug.Assert(valueResultArray[i] != null); Console.WriteLine($"valueResultArray[{i}]: {valueResultArray[i]}"); } // Example output: // //Writing multiple item values... //Results[0]: success //Results[1]: success //Results[2]: success // //Reading multiple item values... //valueResultArray[0]: Success; 12345 {System.Int32} //valueResultArray[1]: Success; True {System.Boolean} //valueResultArray[2]: Success; 234.56 {System.Single} } } }
# Shows how to write into multiple OPC items using a single method call, and read multiple item values back. # # Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . # OPC client and subscriber examples in PowerShell on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PowerShell . # Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own # a commercial license in order to use Online Forums, and we reply to every post. #requires -Version 5.1 using namespace OpcLabs.EasyOpc.DataAccess using namespace OpcLabs.EasyOpc.DataAccess.OperationModel # The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows . Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicCore.dll" Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassic.dll" Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicComponents.dll" # Instantiate the client object. $client = New-Object EasyDAClient Write-Host "Writing multiple item values..." $resultArray = $client.WriteMultipleItemValues(@( (New-Object DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345)), (New-Object DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_BOOL", $true)), (New-Object DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56)) )) for ($i = 0; $i -lt $resultArray.Length; $i++) { $result = $resultArray[$i] if ($result.Succeeded) { Write-Host "Result $($i): success" } else { Write-Host "Result $($i) *** Failure: $($result.ErrorMessageBrief)" } } Write-Host Write-Host "Reading multiple item values..." $valueResultArray = [IEasyDAClientExtension]::ReadMultipleItemValues($client, "OPCLabs.KitServer.2", @( (New-Object DAItemDescriptor("Simulation.Register_I4")), (New-Object DAItemDescriptor("Simulation.Register_BOOL")), (New-Object DAItemDescriptor("Simulation.Register_R4")) )) for ($i = 0; $i -lt $valueResultArray.Length; $i++) { $valueResult = $valueResultArray[$i] Write-Host "valueResultArray[$($i)]: $($valueResult)" } # Example output: # #Writing multiple item values... #Result 0: success #Result 1: success #Result 2: success # #Reading multiple item values... #valueResultArray[0]: Success; 12345 {System.Int32} #valueResultArray[1]: Success; True {System.Boolean} #valueResultArray[2]: Success; 234.56 {System.Single}
' This example shows how to write values into multiple items. ' ' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . ' OPC client and subscriber examples in VB.NET on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBNET . ' Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own ' a commercial license in order to use Online Forums, and we reply to every post. Imports OpcLabs.BaseLib.OperationModel Imports OpcLabs.EasyOpc.DataAccess Imports OpcLabs.EasyOpc.DataAccess.OperationModel Namespace DataAccess._EasyDAClient Partial Friend Class WriteMultipleItemValues Public Shared Sub Main1() Dim client = New EasyDAClient() Dim argumentsArray = New DAItemValueArguments() { _ New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345), _ New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_BOOL", True), _ New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56) _ } Dim resultArray As OperationResult() = client.WriteMultipleItemValues(argumentsArray) For i = 0 To resultArray.Length - 1 Debug.Assert(resultArray(i) IsNot Nothing) If resultArray(i).Succeeded Then Console.WriteLine("Results[{0}]: success", i) Else Console.WriteLine("Results[{0}] *** Failure: {1}", i, resultArray(i).ErrorMessageBrief) End If Next i Console.WriteLine("Reading multiple item values...") Dim valueResultArray() As ValueResult = client.ReadMultipleItemValues("OPCLabs.KitServer.2", _ New DAItemDescriptor() { _ "Simulation.Register_I4", "Simulation.Register_BOOL", "Simulation.Register_R4"}) For i = 0 To valueResultArray.Length - 1 Debug.Assert(valueResultArray(i) IsNot Nothing) Console.WriteLine("valueResultArray[{0}]: {1}", i, valueResultArray(i)) Next i End Sub End Class End Namespace
// This example shows how to write values into 3 items at once. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in Object Pascal (Delphi) on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-OP . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. class procedure WriteMultipleItemValues.Main; var Arguments: OleVariant; Client: OpcLabs_EasyOpcClassic_TLB._EasyDAClient; I: Cardinal; ItemValueArguments1: _DAItemValueArguments; ItemValueArguments2: _DAItemValueArguments; ItemValueArguments3: _DAItemValueArguments; Results: OleVariant; OperationResult: _OperationResult; begin ItemValueArguments1 := CoDAItemValueArguments.Create; ItemValueArguments1.ServerDescriptor.ServerClass := 'OPCLabs.KitServer.2'; ItemValueArguments1.ItemDescriptor.ItemID := 'Simulation.Register_I4'; ItemValueArguments1.Value := 23456; ItemValueArguments2 := CoDAItemValueArguments.Create; ItemValueArguments2.ServerDescriptor.ServerClass := 'OPCLabs.KitServer.2'; ItemValueArguments2.ItemDescriptor.ItemID := 'Simulation.Register_R8'; ItemValueArguments2.Value := 2.34567890; ItemValueArguments3 := CoDAItemValueArguments.Create; ItemValueArguments3.ServerDescriptor.ServerClass := 'OPCLabs.KitServer.2'; ItemValueArguments3.ItemDescriptor.ItemID := 'Simulation.Register_BSTR'; ItemValueArguments3.Value := 'ABC'; Arguments := VarArrayCreate([0, 2], varVariant); Arguments[0] := ItemValueArguments1; Arguments[1] := ItemValueArguments2; Arguments[2] := ItemValueArguments3; // Instantiate the client object Client := CoEasyDAClient.Create; // Modify values of nodes TVarData(Results).VType := varArray or varVariant; TVarData(Results).VArray := PVarArray( Client.WriteMultipleItemValues(Arguments)); // Display results for I := VarArrayLowBound(Results, 1) to VarArrayHighBound(Results, 1) do begin OperationResult := IInterface(Results[I]) as _OperationResult; if OperationResult.Succeeded then WriteLn('Result ', I, ' success') else WriteLn('Result ', I, ' *** Failure: ', OperationResult.Exception.GetBaseException.Message); end; VarClear(Results); VarClear(Arguments); end;
// This example shows how to write values into 3 items at once. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in PHP on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PHP . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. $ItemValueArguments1 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments"); $ItemValueArguments1->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2"; $ItemValueArguments1->ItemDescriptor->ItemID = "Simulation.Register_I4"; $ItemValueArguments1->Value = 23456; $ItemValueArguments2 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments"); $ItemValueArguments2->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2"; $ItemValueArguments2->ItemDescriptor->ItemID = "Simulation.Register_R8"; $ItemValueArguments2->Value = 2.34567890; $ItemValueArguments3 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments"); $ItemValueArguments3->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2"; $ItemValueArguments3->ItemDescriptor->ItemID = "Simulation.Register_BSTR"; $ItemValueArguments3->Value = "ABC"; $arguments[0] = $ItemValueArguments1; $arguments[1] = $ItemValueArguments2; $arguments[2] = $ItemValueArguments3; $Client = new COM("OpcLabs.EasyOpc.DataAccess.EasyDAClient"); $results = $Client->WriteMultipleItemValues($arguments); for ($i = 0; $i < count($results); $i++) { $OperationResult = $results[$i]; if ($OperationResult->Succeeded) printf("Result %d: success\n", $i); else printf("Result d: s\n", $i, $OperationResult->ErrorMessageBrief); }
// Shows how to write into multiple OPC items using a single method call, and itemValue multiple item values back. mle_outputtext.Text = "" // Instantiate the client object OLEObject client client = CREATE OLEObject client.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.EasyDAClient") // Prepare arguments. OLEObject itemValueArguments1 itemValueArguments1 = CREATE OLEObject itemValueArguments1.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") itemValueArguments1.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" itemValueArguments1.ItemDescriptor.ItemID = "Simulation.Register_I4" itemValueArguments1.Value = 12345 OLEObject itemValueArguments2 itemValueArguments2 = CREATE OLEObject itemValueArguments2.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") itemValueArguments2.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" itemValueArguments2.ItemDescriptor.ItemID = "Simulation.Register_BOOL" itemValueArguments2.Value = TRUE OLEObject itemValueArguments3 itemValueArguments3 = CREATE OLEObject itemValueArguments3.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") itemValueArguments3.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" itemValueArguments3.ItemDescriptor.ItemID = "Simulation.Register_R4" itemValueArguments3.Value = 234.56 OLEObject itemValueArgumentsList itemValueArgumentsList = CREATE OLEObject itemValueArgumentsList.ConnectToNewObject("OpcLabs.BaseLib.Collections.ElasticVector") itemValueArgumentsList.Add(itemValueArguments1) itemValueArgumentsList.Add(itemValueArguments2) itemValueArgumentsList.Add(itemValueArguments3) // Modify value of nodes OLEObject operationResultList operationResultList = client.WriteItemValueList(itemValueArgumentsList) // Display results Int i FOR i = 0 TO operationResultList.Count - 1 OLEObject operationResult operationResult = operationResultList.Item[i] IF operationResult.Succeeded THEN mle_outputtext.Text = mle_outputtext.Text + "Result " + String(i) + ": success" + "~r~n" ELSE mle_outputtext.Text = mle_outputtext.Text + "Result " + String(i) + ": " + operationResult.Exception.GetBaseException().Message + "~r~n" END IF NEXT mle_outputtext.Text = mle_outputtext.Text + "~r~n" mle_outputtext.Text = mle_outputtext.Text + "Finished." + "~r~n"
REM This example shows how to write values into 3 items at once. REM REM Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . REM OPC client and subscriber examples in Visual Basic on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VB . REM Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own REM a commercial license in order to use Online Forums, and we reply to every post. Private Sub WriteMultipleItemValues_Main_Command_Click() OutputText = "" Dim itemValueArguments1 As New DAItemValueArguments itemValueArguments1.serverDescriptor.ServerClass = "OPCLabs.KitServer.2" itemValueArguments1.ItemDescriptor.itemId = "Simulation.Register_I4" itemValueArguments1.SetValue 23456 Dim itemValueArguments2 As New DAItemValueArguments itemValueArguments2.serverDescriptor.ServerClass = "OPCLabs.KitServer.2" itemValueArguments2.ItemDescriptor.itemId = "Simulation.Register_R8" itemValueArguments2.SetValue 2.3456789 Dim itemValueArguments3 As New DAItemValueArguments itemValueArguments3.serverDescriptor.ServerClass = "OPCLabs.KitServer.2" itemValueArguments3.ItemDescriptor.itemId = "Simulation.Register_BSTR" itemValueArguments3.SetValue "ABC" Dim arguments(2) As Variant Set arguments(0) = itemValueArguments1 Set arguments(1) = itemValueArguments2 Set arguments(2) = itemValueArguments3 ' Instantiate the client object Dim client As New EasyDAClient ' Modify values of nodes Dim results() As Variant results = client.WriteMultipleItemValues(arguments) ' Display results Dim i: For i = LBound(results) To UBound(results) Dim operationResult As operationResult: Set operationResult = results(i) If operationResult.Succeeded Then OutputText = OutputText & "result " & i & " success" & vbCrLf Else OutputText = OutputText & "result " & i & " *** Failure: " & operationResult.ErrorMessageBrief & vbCrLf End If Next End Sub
Rem This example shows how to write values into 3 items at once. Rem Rem Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . Rem OPC client and subscriber examples in VBScript on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBScript . Rem Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own Rem a commercial license in order to use Online Forums, and we reply to every post. Option Explicit Dim ItemValueArguments1: Set ItemValueArguments1 = CreateObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") ItemValueArguments1.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" ItemValueArguments1.ItemDescriptor.ItemID = "Simulation.Register_I4" ItemValueArguments1.Value = 23456 Dim ItemValueArguments2: Set ItemValueArguments2 = CreateObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") ItemValueArguments2.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" ItemValueArguments2.ItemDescriptor.ItemID = "Simulation.Register_R8" ItemValueArguments2.Value = 2.34567890 Dim ItemValueArguments3: Set ItemValueArguments3 = CreateObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") ItemValueArguments3.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" ItemValueArguments3.ItemDescriptor.ItemID = "Simulation.Register_BSTR" ItemValueArguments3.Value = "ABC" Dim arguments(2) Set arguments(0) = ItemValueArguments1 Set arguments(1) = ItemValueArguments2 Set arguments(2) = ItemValueArguments3 Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.DataAccess.EasyDAClient") Dim results: results = Client.WriteMultipleItemValues(arguments) Dim i: For i = LBound(results) To UBound(results) Dim OperationResult: Set OperationResult = results(i) If OperationResult.Succeeded Then WScript.Echo "Result " & i & ": success" Else WScript.Echo "Result " & i & ": " & OperationResult.Exception.GetBaseException.Message End If Next
# Shows how to write into multiple OPC items using a single method call, and read multiple item values back. # # Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . # OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python . # Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own # a commercial license in order to use Online Forums, and we reply to every post. # The QuickOPC package is needed. Install it using "pip install opclabs_quickopc". import opclabs_quickopc # Import .NET namespaces. from OpcLabs.EasyOpc import * from OpcLabs.EasyOpc.DataAccess import * from OpcLabs.EasyOpc.DataAccess.OperationModel import * from OpcLabs.EasyOpc.OperationModel import * # Instantiate the client object. client = EasyDAClient() print('Writing multiple item values...') operationResultArray = client.WriteMultipleItemValues([ DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_I4'), 12345), DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_BOOL'), True), DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_R4'), 234.56), ]) for i, operationResult in enumerate(operationResultArray): assert operationResult is not None if operationResult.Succeeded: print('operationResultArray[', i, ']: success', sep='') else: assert operationResult.Exception is not None print('operationResultArray[', i, '] *** Failure: ', operationResult.ErrorMessageBrief, sep='') print('Reading multiple item values...') try: valueResultArray = IEasyDAClientExtension.ReadMultipleItemValues(client, ServerDescriptor('OPCLabs.KitServer.2'), [ DAItemDescriptor('Simulation.Register_I4'), DAItemDescriptor('Simulation.Register_BOOL'), DAItemDescriptor('Simulation.Register_R4'), ]) except OpcException as opcException: print('*** Failure: ' + opcException.GetBaseException().Message) exit() for i, valueResult in enumerate(valueResultArray): assert valueResult is not None if valueResult.Succeeded: print('valueResultArray[', i, '].Value: ', valueResult.Value, sep='') else: assert valueResult.Exception is not None print('valueResultArray[', i, '] *** Failure: ', valueResult.ErrorMessageBrief, sep='')
// This example shows how to write values into 3 items at once, test for success of each write and display the exception // message in case of failure. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-CSharp . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. using System; using System.Diagnostics; using OpcLabs.BaseLib.OperationModel; using OpcLabs.EasyOpc.DataAccess; using OpcLabs.EasyOpc.DataAccess.OperationModel; namespace DocExamples.DataAccess._EasyDAClient { partial class WriteMultipleItemValues { public static void TestSuccess() { // Instantiate the client object. var client = new EasyDAClient(); Console.WriteLine("Writing multiple item values..."); OperationResult[] resultArray = client.WriteMultipleItemValues( new[] { new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 23456), new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R8", "This string cannot be converted to VT_R8"), new DAItemValueArguments("", "OPCLabs.KitServer.2", "UnknownItem", "ABC") }); for (int i = 0; i < resultArray.Length; i++) { Debug.Assert(resultArray[i] != null); if (resultArray[i].Succeeded) Console.WriteLine("Result {0}: success", i); else { Debug.Assert(!(resultArray[i].Exception is null)); Console.WriteLine("Result {0} *** Failure: {1}", i, resultArray[i].ErrorMessageBrief); } } } // Example output: // //Writing multiple item values... //Result 0: success //Result 1 *** Failure: Type mismatch. [...] //Result 2 *** Failure: The item is no longer available in the server address space. [...] } }
' This example shows how to write values into 3 items at once, test for success of each write and display the exception ' message in case of failure. ' ' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . ' OPC client and subscriber examples in VB.NET on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBNET . ' Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own ' a commercial license in order to use Online Forums, and we reply to every post. Imports OpcLabs.BaseLib.OperationModel Imports OpcLabs.EasyOpc.DataAccess Imports OpcLabs.EasyOpc.DataAccess.OperationModel Namespace DataAccess._EasyDAClient Partial Friend Class WriteMultipleItemValues Public Shared Sub TestSuccess() ' Instantiate the client object. Dim client = New EasyDAClient() Console.WriteLine("Writing multiple item values...") Dim resultArray As OperationResult() = client.WriteMultipleItemValues(New DAItemValueArguments() { New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 23456), New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R8", "This string cannot be converted to VT_R8"), New DAItemValueArguments("", "OPCLabs.KitServer.2", "UnknownItem", "ABC") }) For i = 0 To resultArray.Length - 1 Debug.Assert(resultArray(i) IsNot Nothing) If resultArray(i).Succeeded Then Console.WriteLine("Result {0}: success", i) Else Debug.Assert(resultArray(i).Exception IsNot Nothing) Console.WriteLine("Result {0} *** Failure: {1}", i, resultArray(i).ErrorMessageBrief) End If Next i End Sub ' Example output ' 'Writing multiple item values... 'Result 0: success 'Result 1 *** Failure: Type mismatch. [...] 'Result 2 *** Failure: The item Is no longer available In the server address space. [...] End Class End Namespace
// This example shows how to write values into 3 items at once, test for success of each write and display the exception // message in case of failure. // // Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . // OPC client and subscriber examples in PHP on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PHP . // Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own // a commercial license in order to use Online Forums, and we reply to every post. $ItemValueArguments1 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments"); $ItemValueArguments1->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2"; $ItemValueArguments1->ItemDescriptor->ItemID = "Simulation.Register_I4"; $ItemValueArguments1->Value = 23456; $ItemValueArguments2 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments"); $ItemValueArguments2->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2"; $ItemValueArguments2->ItemDescriptor->ItemID = "Simulation.Register_R8"; $ItemValueArguments2->Value = "This string cannot be converted to VT_R8"; $ItemValueArguments3 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments"); $ItemValueArguments3->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2"; $ItemValueArguments3->ItemDescriptor->ItemID = "UnknownItem"; $ItemValueArguments3->Value = "ABC"; $arguments[0] = $ItemValueArguments1; $arguments[1] = $ItemValueArguments2; $arguments[2] = $ItemValueArguments3; $Client = new COM("OpcLabs.EasyOpc.DataAccess.EasyDAClient"); $results = $Client->WriteMultipleItemValues($arguments); for ($i = 0; $i < count($results); $i++) { $OperationResult = $results[$i]; if ($OperationResult->Succeeded) printf("Result %d: success\n", $i); else printf("Result d: s\n", $i, $OperationResult->ErrorMessageBrief); }
Rem This example shows how to write values into 3 items at once, test for success of each write and display the exception Rem message in case of failure. Rem Rem Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html . Rem OPC client and subscriber examples in VBScript on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBScript . Rem Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own Rem a commercial license in order to use Online Forums, and we reply to every post. Option Explicit Dim ItemValueArguments1: Set ItemValueArguments1 = CreateObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") ItemValueArguments1.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" ItemValueArguments1.ItemDescriptor.ItemID = "Simulation.Register_I4" ItemValueArguments1.Value = 23456 Dim ItemValueArguments2: Set ItemValueArguments2 = CreateObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") ItemValueArguments2.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" ItemValueArguments2.ItemDescriptor.ItemID = "Simulation.Register_R8" ItemValueArguments2.Value = "This string cannot be converted to VT_R8" Dim ItemValueArguments3: Set ItemValueArguments3 = CreateObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments") ItemValueArguments3.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2" ItemValueArguments3.ItemDescriptor.ItemID = "UnknownItem" ItemValueArguments3.Value = "ABC" Dim arguments(2) Set arguments(0) = ItemValueArguments1 Set arguments(1) = ItemValueArguments2 Set arguments(2) = ItemValueArguments3 Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.DataAccess.EasyDAClient") Dim results: results = Client.WriteMultipleItemValues(arguments) Dim i: For i = LBound(results) To UBound(results) Dim OperationResult: Set OperationResult = results(i) If OperationResult.Succeeded Then WScript.Echo "Result " & i & ": success" Else WScript.Echo "Result " & i & ": " & OperationResult.Exception.GetBaseException.Message End If Next
If you need to write a combination of value, timestamps, and status code be written, and your OPC server support this, see Writing value, timestamps and status code (OPC UA).
Copyright © 2004-2024 CODE Consulting and Development, s.r.o., Plzen. All rights reserved. Web page: www.opclabs.com
Documentation Home, Send Feedback. Resources: Knowledge Base, Product Downloads. Technical support: Online Forums, FAQ.Missing some example? Ask us for it on our Online Forums! You do not have to own a commercial license in order to use Online Forums, and we reply to every post.